﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data;
using IQReportes.Utils;

namespace IQReportes.Models
{
    public class SimuladorBD
    {
        /*private FuncionesGenericas funciones = new FuncionesGenericas();
        private Excel excel = new Excel();
        private DataSet dsUbigeo = new DataSet();

        private Dictionary<int, string> diccionarioDistritos = new Dictionary<int, string>(); //dato inicial
        private Dictionary<string, string> diccionarioTipos = new Dictionary<string, string>(); //dato inicial
        private Dictionary<string, string> diccionarioMovimientos = new Dictionary<string, string>();
        private Dictionary<int, Ubigeo> diccionarioUbigeo = new Dictionary<int, Ubigeo>(); //dato inicial
        private Dictionary<string, DIR> diccionarioDIR = new Dictionary<string, DIR>(); //dato inicial
        private Dictionary<string, string> diccionarioLocales = new Dictionary<string, string>(); //dato inicial
        private Dictionary<string, int> diccionarioConsLocales = new Dictionary<string, int>();
        private Dictionary<string, int> diccionarioDIRxLocal = new Dictionary<string, int>();


        List<String> departamentos = new List<String>();//dato inicial
        List<Ubigeo> listaUbigeo = new List<Ubigeo>(); //dato inicial
        List<TipoTransaccion> listaTipos = new List<TipoTransaccion>();//dato inicial
        List<DIR> listaDIR = new List<DIR>();//dato inicial
        List<Transaccion> transacciones;//dato inicial

        IQueryable<Transaccion> queryTransacciones;

        private const int MAX_CANT_TXN = 50; //cantidad maxima de txn por local
        private const int MAX_CANT_DIR = 5; //cantidad maxima de dirs por local
        private const int MAX_CANT_LOC = 10; //cantidad maxima de locales por distrito

        private const int MIN_CANT_TXN = 0;
        private const int MIN_CANT_DIR = 1;
        private const int MIN_CANT_LOC = 1;

        private const int LIMITE_ITERA = 1000;

        public void cargaDatosIniciales()
        {

            obtenerUbigeosExcel();
            obtenerDepartamentos();
            obtenerDIRSExcel();
            obtenerTiposCategoriasTxn();
            construirBDTransacciones();
        }
        //******************************************** INICIO CARGA DE DATOS GENERALES **************************

        //Obtiene los ubigeos distrito, provincia, departamento
        public void obtenerUbigeosExcel()
        {
            DataSet dsUbigeo = excel.obtenerDataExcel(Constantes.PATH_ARCHIVOS, "Parametros.xlsx", "Hoja1");
            try
            {
                var listaUbigeoExcel = dsUbigeo.Tables[0].AsEnumerable().Select(k =>
                    new Ubigeo()
                    {
                        nombreDepartamento = k.Field<string>("Departamento"),
                        nombreProvincia = k.Field<string>("Provincia"),
                        nombreDistrito = k.Field<string>("Distrito"),
                        codigoDistrito = k.Field<double>("idDistrito")
                    });

                listaUbigeo = listaUbigeoExcel.ToList();
                string espacios;
                foreach (Ubigeo u in listaUbigeo)
                {
                    espacios = Constantes.CADENA_VACIA;
                    while (true)
                    {
                        if (diccionarioDistritos.ContainsValue(u.nombreDistrito + espacios))
                        {
                            espacios = espacios + " ";
                        }
                        else
                        {
                            diccionarioDistritos.Add(u.CodigoIntDistrito, u.nombreDistrito + espacios);
                            break;
                        }
                    }
                    
                    diccionarioUbigeo.Add(u.CodigoIntDistrito, u);
                }
            }

            catch (Exception e)
            {
                string gg = e.Message;
            }
        }

        //Obtiene de un archivo de excel los tipos y categorias que van haber
        public void obtenerTiposCategoriasTxn()
        {
            DataSet dsTipos = excel.obtenerDataExcel(Constantes.PATH_ARCHIVOS, "Parametros.xlsx", "Hoja2");
            try
            {
                var listaTiposExcel = dsTipos.Tables[0].AsEnumerable().Select(k =>
                    new TipoTransaccion()
                    {
                        nombreTransaccion = k.Field<string>("Nombre Txn"),
                        categoriaTransaccion = k.Field<string>("Categoria"),
                        categoriaMonto = k.Field<string>("Movimiento")
                    });

                listaTipos = listaTiposExcel.ToList();
                foreach (TipoTransaccion t in listaTipos)
                {
                    diccionarioTipos.Add(t.nombreTransaccion, t.categoriaTransaccion);
                    diccionarioMovimientos.Add(t.nombreTransaccion, t.categoriaMonto);
                }

            }
            catch (Exception e)
            {
                string gg = e.Message;
            }
        }

        //obtener DIRs del excel de comercios

        private void obtenerDIRSExcel()
        {
            DataSet dsDIR = excel.obtenerDataExcel(Constantes.PATH_ARCHIVOS, "Parametros.xlsx", "Hoja3");
            try
            {
                var listaDIRExcel = dsDIR.Tables[0].AsEnumerable().Select(k =>
                    new DIR()
                    {
                        codDIR = k.Field<string>("DIR"),
                        local = k.Field<string>("Nombre Comercial"),
                        dblRUC = k.Field<double?>("RUC"),
                        distrito = k.Field<string>("Distrito"),
                        departamento = k.Field<string>("Dpto"),
                        provincia = k.Field<string>("Provincia")

                    });



                listaDIR = listaDIRExcel.ToList(); //ACA HAY DIRS REPETIDOS PERO NO AFECTARA YA QUE EN EL DICCIONARIO
                //ESTOS NO SE REPITEN

                //Quitarle la tilde al distroto

                //ubicamos su exacto ubigeo
                string espacios;
                foreach (DIR d in listaDIR)
                {
                    d.provincia = funciones.quitarTildes(d.provincia).Trim();
                    d.distrito = funciones.quitarTildes(d.distrito).Trim();
                    var auxUbigeo = listaUbigeo.AsQueryable().Where(a => a.nombreProvincia == d.provincia.ToUpper() && a.nombreDistrito == d.distrito.ToUpper());
                    if (auxUbigeo.Count() > 0)
                    {
                        d.codDistrito = auxUbigeo.First().CodigoIntDistrito;
                        d.distrito = diccionarioDistritos[(int)d.codDistrito]; //obtiene el nombre unico del distrito
                        if (!diccionarioDIR.ContainsKey(d.codDIR))
                        {
                            diccionarioDIR.Add(d.codDIR, d);

                            espacios = Constantes.CADENA_VACIA;
                            while (true)
                            {
                                if (diccionarioLocales.ContainsValue(d.local.Trim() + espacios))
                                {
                                    espacios = espacios + " ";
                                }
                                else
                                {
                                    diccionarioLocales.Add(d.codDIR, d.local.Trim() + espacios);
                                    break;
                                }
                            }
                                                       
                        }


                    }
                    else
                    {
                        d.codDistrito = null;
                    }
                }

                //var ggg = listaDIR.AsQueryable().Where(a => a.codDistrito == null);
                //int cant = ggg.Count();
            }

            catch (Exception e)
            {
                string gg = e.Message;
            }
        }

        //Obtener las transacciones del archivo CSV
        private void construirBDTransacciones()
        {
            try
            {
                transacciones = excel.obtenerTransaccionesCsv(Constantes.PATH_ARCHIVOS, "estadisticas_iq_10072013_11.csv");
                Ubigeo ubigeoDIR;
                DateTime fecha = DateTime.Now.AddDays(-1);
                //completar los campos restantes
                int i = 0;
                int limite = LIMITE_ITERA;
                while (limite < transacciones.Count())
                {
                    while (i < limite)
                    {
                        transacciones[i].vcNombreCategoria = diccionarioTipos[transacciones[i].vcNombreTransaccion];
                        transacciones[i].vcNombreMovimiento = diccionarioMovimientos[transacciones[i].vcNombreTransaccion];
                        //A Partir del DIR obtener su ubigeo
                        ubigeoDIR = obtenerUbigeoDIR(transacciones[i].vcDIR); //Aca es el problema
                        if (ubigeoDIR != null)
                        {
                            transacciones[i].vcNombreProvincia = ubigeoDIR.nombreProvincia;
                            transacciones[i].vcCodProvincia = ubigeoDIR.nombreProvincia;

                            transacciones[i].vcNombreDepartamento = ubigeoDIR.nombreDepartamento;
                            transacciones[i].vcCodDepartamento = ubigeoDIR.nombreDepartamento;

                            transacciones[i].vcNombreDistrito = diccionarioDistritos[ubigeoDIR.CodigoIntDistrito];
                            transacciones[i].vcCodDistrito = ubigeoDIR.CodigoIntDistrito.ToString();
                            if (diccionarioDIR.ContainsKey(transacciones[i].vcDIR))
                            {
                                transacciones[i].vcLocal = diccionarioDIR[transacciones[i].vcDIR].local;
                            }
                            else
                            {
                                transacciones[i].vcLocal = null;
                            }
                            //IMPORTANTE FALTA DEFINIR FECHA
                            transacciones[i].dtFecha = fecha;

                            transacciones[i].vcSemana = funciones.calcularSemana(fecha);
                            transacciones[i].vcMes = funciones.calcularMes(fecha);
                            transacciones[i].inAno = funciones.calcularAno(fecha);
                        }
                        else
                        {
                            transacciones[i].vcCodDistrito = null;
                        }
                        i = i + 1;
                        //Conseguir la fecha, semana, mes, año
                    }
                    if (limite == transacciones.Count())
                    {
                        break;
                    }
                    else if ((limite + LIMITE_ITERA) < transacciones.Count())
                    {
                        limite = limite + LIMITE_ITERA;
                    }
                    else
                    {
                        limite = transacciones.Count();
                    }

                }
                transacciones = transacciones.AsQueryable().Where(a => a.vcCodDistrito != null && a.vcLocal != null).ToList();
                queryTransacciones = transacciones.AsQueryable();

                var auxConsolidado = transacciones.GroupBy(a => new
                {
                    a.vcLocal
                }).Select(a => new
                {
                    nombreLocal = a.Key.vcLocal,
                    numTxn = a.Count(),
                    numDIRs = a.Select(x => x.vcDIR).Distinct().Count()
                });

                foreach (var elemento in auxConsolidado)
                {
                    diccionarioConsLocales.Add(elemento.nombreLocal, elemento.numTxn);
                    diccionarioDIRxLocal.Add(elemento.nombreLocal, elemento.numDIRs);
                }
            }
            catch (Exception e)
            {
                string gg = e.Message;
            }
        }

        private Ubigeo obtenerUbigeoDIR(string DIR)
        {
            DIR dir;
            //Ubigeo ubigeoRetorno;
            var auxDIR = listaDIR.Where(a => a.codDIR == DIR);
            if (auxDIR.Count() > 0)
            {
                dir = auxDIR.First();
                if (dir.codDistrito != null)
                {
                    if (diccionarioUbigeo.ContainsKey((int)dir.codDistrito))
                    {
                        return diccionarioUbigeo[(int)dir.codDistrito];
                    }
                    //var auxUbigeo = listaUbigeo.AsQueryable().Where(a => a.CodigoIntDistrito == auxDIR.First().codDistrito);
                    //if (auxUbigeo.Count() > 0)
                    //{
                    //    return auxUbigeo.First();
                    //}
                }
            }
            return null;
        }
        //******************************************** FIN CARGA DE DATOS GENERALES **************************

        //*************************************************INICIA CONSOLIDADO TREE**********************************

        public List<TreeTransaccion> obtenerConsTreeSimulacionDB(int rango)
        {
            List<TreeTransaccion> tree = new List<TreeTransaccion>();
            List<String> locales = new List<String>();
            List<String> auxDistritos = new List<String>();
            List<String> auxProvincias = new List<String>();
            List<String> auxDepartamentos = new List<String>();
            List<String> auxDistritos1 = new List<String>();
            List<String> auxProvincias1 = new List<String>();
            List<String> auxDepartamentos1 = new List<String>();
            //int localBase = 0;

            foreach (String d in departamentos)
            {
                auxDepartamentos1.Add("Dpto. " + d);
            }//Agregar departamentos al tree
            foreach (String d in departamentos)
            {
                auxProvincias1 = obtenerProvinciasXDepartamento(d, auxProvincias);
                agregarHijosTree("Dpto. "+d, auxProvincias1, tree, false);

                foreach (String p in auxProvincias)
                {
                    auxDistritos1 = obtenerDistritosXProvincia(d, p, auxDistritos);
                    agregarHijosTree("Prov. " + p, auxDistritos1, tree, false);

                    foreach (String dist in auxDistritos)
                    {
                        //localBase = obtenerLocalesXdistrito(locales, dist, localBase);
                        obtenerLocalesXdistrito(locales, dist);
                        if (locales != null && locales.Count() > 0)
                        {
                            agregarHijosTree("Dist. " + dist, locales, tree, true);
                        }
                        locales = new List<String>();
                    }

                    auxDistritos = new List<String>();
                }

                auxProvincias = new List<String>();
            }
            //Agregar departamentos al tree
            
            agregarHijosTree("Peru", auxDepartamentos1, tree, false);
            TreeTransaccion elementoTree = new TreeTransaccion();
            elementoTree.vcHijo = "Peru";
            elementoTree.vcPadre = null;
            tree.Add(elementoTree);
            return tree;
        }

        public void agregarHijosTree(String padre, List<String> hijos, List<TreeTransaccion> tree, bool ultimoNivel)
        {
            TreeTransaccion elementoTree;
            foreach (String hijo in hijos)
            {
                elementoTree = new TreeTransaccion();
                elementoTree.vcHijo = hijo;
                elementoTree.vcPadre = padre;
                if (ultimoNivel)
                {
                    elementoTree.inCantidadTransacciones = obtenerCantTxnReal(hijo);//obtenerCantTxnAleatorias();
                    elementoTree.inCantidadDIR = obtenerCantDIRReal(hijo);//obtenerCantDirAleatorios();
                }
                tree.Add(elementoTree);
            }
        }

        private int obtenerCantTxnReal(string nombreLocal)
        {
            int cantidad;
            if (diccionarioConsLocales.ContainsKey(nombreLocal))
            {
                cantidad = diccionarioConsLocales[nombreLocal];
            }
            else
            {
                cantidad = 0;
            }
            return cantidad;

        }

        private int obtenerCantDIRReal(string nombreLocal)
        {
            int cantidad;
            if (diccionarioDIRxLocal.ContainsKey(nombreLocal))
            {
                cantidad = diccionarioDIRxLocal[nombreLocal];
            }
            else
            {
                cantidad = 0;
            }
            return cantidad;

        }

        private int obtenerCantTxnAleatorias()
        {
            int cantidad;
            cantidad = funciones.obtenerNumeroAleatorio(MIN_CANT_TXN, MAX_CANT_TXN);
            return cantidad;
        }

        private int obtenerCantDirAleatorios()
        {
            int cantidad;
            cantidad = funciones.obtenerNumeroAleatorio(MIN_CANT_DIR, MAX_CANT_DIR);
            return cantidad;
        }

        public void obtenerDirsXlocal()
        {

        }


        public List<String> obtenerProvinciasXDepartamento(string nombreDepartamento, List<String> provincias)
        {
            List<String> retorno = new List<String>();
            try
            {
                var provs = listaUbigeo.AsEnumerable().Where(a => a.nombreDepartamento ==
                    nombreDepartamento).GroupBy(a => a.nombreProvincia).Select(k => new { Provincia = k.Key }).ToList();


                foreach (var u in provs)
                {
                    provincias.Add(u.Provincia);
                    retorno.Add("Prov. " + u.Provincia);
                }
                return retorno;
            }
            catch (Exception e)
            {
                string gg = e.Message;
            }
            return null;
        }

        public List<String> obtenerDistritosXProvincia(string departamento, string provincia, List<String> distritos)
        {
            List<String> retorno = new List<String>();
            try
            {
                var dist = listaUbigeo.AsEnumerable().Where(a => a.nombreDepartamento ==
                    departamento && a.nombreProvincia == provincia).GroupBy(a => a.CodigoIntDistrito).Select(
                    k => new { Distrito = k.Key }).ToList();

                foreach (var u in dist)
                {
                    distritos.Add(diccionarioDistritos[u.Distrito]);
                    retorno.Add("Dist. " + diccionarioDistritos[u.Distrito]);
                }
                return retorno;
            }
            catch (Exception e)
            {
                string gg = e.Message;
            }
            return null;
        }

        //public void obtenerLocalesXdistrito(List<String> listaLocales, string codDistrito, int localBase)
        public void obtenerLocalesXdistrito(List<String> listaLocales, string codDistrito)
        {

            var auxDIRS = listaDIR.AsQueryable().Where(a => a.distrito == codDistrito);

            if (auxDIRS.Count() > 0)
            {
                foreach (DIR d in auxDIRS)
                {
                    if (!listaLocales.Any(d.local.Trim().Contains))
                    {
                        listaLocales.Add(diccionarioLocales[d.codDIR]);
                    }
                }
            }
            else
            {
                listaLocales = null;
            }
            /*
            int cantidadLocales;
            int nuevaBase;

            cantidadLocales = funciones.obtenerNumeroAleatorio(MIN_CANT_LOC, MAX_CANT_LOC);
            
            for (int i = 0; i < cantidadLocales; i++)
            {
                listaLocales.Add("Local " + (i+localBase));
            }

            nuevaBase = localBase + cantidadLocales + 1;

            //return nuevaBase;
        }

        public void obtenerDepartamentos()
        {

            try
            {
                var dptos = listaUbigeo.AsEnumerable().GroupBy(a => a.nombreDepartamento).Select(k => new { Departamento = k.Key }).ToList();
                for (int i = 0; i < dptos.Count(); i++)
                {
                    departamentos.Add(dptos[i].Departamento);
                }
            }
            catch (Exception e)
            {
                string gg = e.Message;
            }
        }
        //*******************************************FIN CONSOLIDADO TREE******************************************

        //******************************************INICIA CONSOLIDADO TIPOS*************************************
        public List<ConsolidadoTipoTransaccion> obtenerConsolidadoTipos(int? rango, DateTime? desde, DateTime? hasta,
                                                                    string estado, string categoria, int nivel,
                                                                    string elementoHijoNivel, string elementoPadreNivel)
        {

            List<ConsolidadoTipoTransaccion> consolidadoTipos = new List<ConsolidadoTipoTransaccion>();

            ConsolidadoTipoTransaccion consTipo;
            //IEnumerable<Object> auxConsolidado;
            IQueryable<Transaccion> txns;
            txns = queryTransacciones;

            txns = filtrarTxnGeneral(txns, elementoHijoNivel, elementoPadreNivel, nivel, estado, categoria, null);

            //FALTA VERIFICAR SI VOY AGRUPAR POR DIAS, SEMANAS, MESES O AÑOS
            var auxConsolidado = txns.GroupBy(a => new
            {
                a.vcNombreCategoria,
                a.dtFecha
            }).Select(a => new
            {
                nombreTxn = a.Key.vcNombreCategoria,
                fecha = a.Key.dtFecha,
                numTxn = a.Count()
            });

            if (categoria != null && !Constantes.CADENA_VACIA.Equals(categoria))
            {
                auxConsolidado = txns.GroupBy(a => new
                {
                    a.vcNombreTransaccion,
                    a.dtFecha
                }).Select(a => new
                {
                    nombreTxn = a.Key.vcNombreTransaccion,
                    fecha = a.Key.dtFecha,
                    numTxn = a.Count()
                });
            }

            foreach (var elemento in auxConsolidado)
            {
                consTipo = new ConsolidadoTipoTransaccion();
                consTipo.vcNombreTipoTransaccion = elemento.nombreTxn;
                consTipo.inCantidad = elemento.numTxn;
                consTipo.dtFecha = elemento.fecha;
                //agregar los demas campos
                consolidadoTipos.Add(consTipo);
            }

            return consolidadoTipos;
        }


        //******************************************FIN CONSOLIDADO TIPOS*************************************


        //******************************************INICIO CONSOLIDADO ESTADOS*************************************

        public List<ConsolidadoEstadoTransaccion> obtenerConsolidadoEstados(int? rango, DateTime? desde, DateTime? hasta,
                                                                            string tipoTransaccion, string categoria, int nivel,
                                                                            string elementoHijoNivel, string elementoPadreNivel)
        {
            List<ConsolidadoEstadoTransaccion> consolidadoEstados = new List<ConsolidadoEstadoTransaccion>();
            ConsolidadoEstadoTransaccion consEstado;

            //si es por dia entonces por fecha, si es por es entonces por semana, etc...

            IQueryable<Transaccion> txns;
            txns = queryTransacciones;

            txns = filtrarTxnGeneral(txns, elementoHijoNivel, elementoPadreNivel, nivel, null, categoria, tipoTransaccion);

            //FALTA VERIFICAR SI VOY AGRUPAR POR DIAS, SEMANAS, MESES O AÑOS
            var auxConsolidado = txns.GroupBy(a => new
            {
                a.vcEstado,
                a.dtFecha
            }).Select(a => new
            {
                nombreEstado = a.Key.vcEstado,
                fecha = a.Key.dtFecha,
                numTxn = a.Count()
            });

            foreach (var elemento in auxConsolidado)
            {
                consEstado = new ConsolidadoEstadoTransaccion();
                consEstado.vcEstado = elemento.nombreEstado;
                consEstado.inCantidad = elemento.numTxn;
                consEstado.dtFecha = elemento.fecha;
                //agregar los demas campos
                consolidadoEstados.Add(consEstado);
            }

            return consolidadoEstados;
        }

        //******************************************FIN CONSOLIDADO ESTADOS*************************************


        //******************************************INICIO CONSOLIDADO MONTOS*************************************

        public List<ConsolidadoMontoTransaccion> obtenerConsolidadoMontos(int? rango, DateTime? desde, DateTime? hasta,
                                                                        string estado, string categoria, string tipoTransaccion,
                                                                        int nivel, string elementoHijoNivel, string elementoPadreNivel)
        {
            List<ConsolidadoMontoTransaccion> consolidadoMontos = new List<ConsolidadoMontoTransaccion>();
            ConsolidadoMontoTransaccion consMonto;

            IQueryable<Transaccion> txns;
            txns = queryTransacciones;

            txns = filtrarTxnGeneral(txns, elementoHijoNivel, elementoPadreNivel, nivel, estado, categoria, tipoTransaccion);

            //para cargos un consolidado y para abonos otro. sumando el campo monto
            var auxConsolidado = txns.GroupBy(a => new
            {
                a.dtFecha,
                a.vcNombreMovimiento

            }).Select(a => new
            {
                fecha = a.Key.dtFecha,
                movimiento = a.Key.vcNombreMovimiento,
                suma = a.Sum(x => x.dbMonto)
            });

            double abono = 0;
            double cargo = 0;
            double transf = 0;
            DateTime fecha = new DateTime();
            foreach (var elemento in auxConsolidado)
            {
                //agregar los demas campos
                fecha = elemento.fecha;
                //consMonto.dbAbono = elemento.suma;

                if (elemento.movimiento.Equals("Abono"))
                {
                    abono = elemento.suma;
                }
                else if (elemento.movimiento.Equals("Cargo"))
                {
                    transf = elemento.suma;
                }
                else if (elemento.movimiento.Equals("Transferencia"))
                {
                    cargo = elemento.suma;
                }
            }
            consMonto = new ConsolidadoMontoTransaccion();
            consMonto.dtFecha = fecha;
            consMonto.dbCargo = cargo / 100;
            consMonto.dbAbono = abono / 100;
            consMonto.dbTransferencia = transf / 100;

            consolidadoMontos.Add(consMonto);

            return consolidadoMontos;
        }

        //******************************************FIN CONSOLIDADO MONTOS*************************************

        //*************************************** INICIO METODOS COMPARTIDOS **********************************

        private IQueryable<Transaccion> filtrarTxnGeneral(IQueryable<Transaccion> txns, string elementoHijoNivel,
                                        string elementoPadreNivel, int nivel, string estado, string categoria,
                                        string tipoTransaccion)
        {
            switch (nivel)
            {
                case 1: //Locales
                    txns = txns.Where(a => a.vcCodDistrito == elementoPadreNivel && a.vcLocal == elementoHijoNivel);
                    break;
                case 2: //distritos
                    txns = txns.Where(a => a.vcCodProvincia == elementoPadreNivel && a.vcCodDistrito == elementoHijoNivel);
                    break;
                case 3: //provincias
                    txns = txns.Where(a => a.vcCodProvincia == elementoHijoNivel);
                    break;
                case 4: //departamentos
                    txns = txns.Where(a => a.vcCodDepartamento == elementoHijoNivel);
                    break;
            }
            if (categoria != null && !Constantes.CADENA_VACIA.Equals(categoria))
            {// Filtrar por categoria
                txns = txns.Where(a => a.vcNombreCategoria == categoria);
            }
            if (estado != null && !Constantes.CADENA_VACIA.Equals(estado))
            {// Filtrar por Estados
                txns = txns.Where(a => a.vcEstado == estado);
            }
            if (tipoTransaccion != null && !Constantes.CADENA_VACIA.Equals(tipoTransaccion))
            {
                txns = txns.Where(a => a.vcNombreTransaccion == tipoTransaccion);
            }
            return txns;
        }

        //***************************************** FIN METODOS COMPARTIDOS ***********************************
        */
    }
}